55 research outputs found
Polynomial Interpretations for Higher-Order Rewriting
The termination method of weakly monotonic algebras, which has been defined
for higher-order rewriting in the HRS formalism, offers a lot of power, but has
seen little use in recent years. We adapt and extend this method to the
alternative formalism of algebraic functional systems, where the simply-typed
lambda-calculus is combined with algebraic reduction. Using this theory, we
define higher-order polynomial interpretations, and show how the implementation
challenges of this technique can be tackled. A full implementation is provided
in the termination tool WANDA
A Calculus for Modular Loop Acceleration and Non-Termination Proofs
Loop acceleration can be used to prove safety, reachability, runtime bounds,
and (non-)termination of programs. To this end, a variety of acceleration
techniques has been proposed. However, so far all of them have been monolithic,
i.e., a single loop could not be accelerated using a combination of several
different acceleration techniques. In contrast, we present a calculus that
allows for combining acceleration techniques in a modular way and we show how
to integrate many existing acceleration techniques into our calculus. Moreover,
we propose two novel acceleration techniques that can be incorporated into our
calculus seamlessly. Some of these acceleration techniques apply only to
non-terminating loops. Thus, combining them with our novel calculus results in
a new, modular approach for proving non-termination. An empirical evaluation
demonstrates the applicability of our approach, both for loop acceleration and
for proving non-termination.Comment: arXiv admin note: substantial text overlap with arXiv:2001.0151
Verifying procedural programs via constrained rewriting induction
This paper aims to develop a verification method for procedural programs via a transformation into Logically Constrained Term Rewriting Systems (LCTRSs). To this end, we extend transformation methods based on integer TRSs to handle arbitrary data types, global variables, function calls and arrays, as well as encode safety checks. Then we adapt existing rewriting induction methods to LCTRSs and propose a simple yet effective method to generalize equations. We show that we can automatically verify memory safety and prove correctness of realistic functions. Our approach proves equivalence between two implementations, so in contrast to other works, we do not require an explicit specification in a separate specification language
On Complexity Bounds and Confluence of Parallel Term Rewriting
We revisit parallel-innermost term rewriting as a model of parallel
computation on inductive data structures and provide a corresponding notion of
runtime complexity parametric in the size of the start term. We propose
automatic techniques to derive both upper and lower bounds on parallel
complexity of rewriting that enable a direct reuse of existing techniques for
sequential complexity. Our approach to find lower bounds requires confluence of
the parallel-innermost rewrite relation, thus we also provide effective
sufficient criteria for proving confluence. The applicability and the precision
of the method are demonstrated by the relatively light effort in extending the
program analysis tool AProVE and by experiments on numerous benchmarks from the
literature.Comment: Under submission to Fundamenta Informaticae. arXiv admin note:
substantial text overlap with arXiv:2208.0100
Analysing Parallel Complexity of Term Rewriting
We revisit parallel-innermost term rewriting as a model of parallel
computation on inductive data structures and provide a corresponding notion of
runtime complexity parametric in the size of the start term. We propose
automatic techniques to derive both upper and lower bounds on parallel
complexity of rewriting that enable a direct reuse of existing techniques for
sequential complexity. The applicability and the precision of the method are
demonstrated by the relatively light effort in extending the program analysis
tool AProVE and by experiments on numerous benchmarks from the literature.Comment: Extended authors' accepted manuscript for a paper accepted for
publication in the Proceedings of the 32nd International Symposium on
Logic-based Program Synthesis and Transformation (LOPSTR 2022). 27 page
Estimation of Parallel Complexity with Rewriting Techniques
International audienceWe show how monotone interpretations – a termination analysis technique for term rewritingsystems – can be used to assess the inherent parallelism of recursive programs manipulatinginductive data structures. As a side effect, we show how monotone interpretations specify aparallel execution order, and how our approach extends naturally affine scheduling – a powerfulanalysis used in parallelising compilers – to recursive programs. This work opens new perspectivesin automatic parallelisation
Termination of Integer Term Rewriting
Recently, techniques and tools from term rewriting have been successfully applied to prove termination automatically for different programming languages. The advantage of rewrite techniques is that they are very powerful for algorithms on user-defined data structures. But in contrast to techniques for termination analysis of imperative programs, the drawback of rewrite techniques is that they do not support data structures like integer numbers which are pre-defined in almost all programming languages.
To solve this problem, we extend term rewriting by built-in integers and adapt the dependency pair framework to prove termination of integer term
rewriting automatically. Our experiments show that this indeed combines the power of rewrite techniques on user-defined data types with a powerful treatment of pre-defined integers
Disproving termination with overapproximation
When disproving termination using known techniques (e.g. recurrence sets), abstractions that overapproximate the program’s transition relation are unsound. In this paper we introduce live abstractions, a natural class of abstractions that can be combined with the recent concept of closed recurrence sets to soundly disprove termination. To demonstrate the practical usefulness of this new approach we show how programs with nonlinear, nondeterministic, and heap-based commands can be shown nonterminating using linear overapproximations
- …